/* ********************************************************************* */
/*                                                                       */
/*                       Librairies de UE                                */
/*                                                                       */
/* ********************************************************************* */

#include "UE.h"


/* ********************************************************************* */
/*                                                                       */
/*                        Les Fonctions                                  */
/*                                                                       */
/* ********************************************************************* */

void initUE(UE *ue,const int codeUE,const char *intitule,const int sequence)
{
    assert(codeUE > 0);
    assert(intitule != NULL);
    assert(sequence > 0);

    ue->codeUE   = codeUE;
    ue->intitule = (char *)intitule;
    ue->sequence = sequence;
}

void libUE(UE *ue)
{
    ue->codeUE   = 0;
    ue->intitule = NULL;
    ue->sequence = 0;
}


UE *creUE(const int codeUE, const char *intitule, const int sequence)
{
    UE *ue;
    ue = (UE *) calloc(1,sizeof(UE));
    initUE(ue, codeUE, intitule, sequence);

    return ue ;
}

void detUE(UE ** ue)
{
    assert(*ue != NULL);
    libUE(*ue);
    free(*ue);
    *ue = NULL ;
}

/* ******************************************************************** */
/*																		*/
/*           Accesseurs et Mutateurs de la structure UE                 */
/*																		*/
/* ******************************************************************** */

int getCodeUE(const UE * ue)
{
    if(ue && (ue->codeUE>0))
        return ue->codeUE;
    else
        return 0;
}

void setCodeUE(UE * ue, int codeUE)
{
    assert(codeUE > 0);
    if(ue)
        ue->codeUE = codeUE;
}

char * getIntitule(const UE * ue)
{
    if(ue && (ue->intitule!=NULL))
        return ue->intitule;
    else
        return 0;
}

void setIntitule(UE * ue,char * intitule)
{
    assert(intitule != NULL);
    if(ue)
        ue->intitule = intitule;
}

int getSequence(UE * ue)
{
    if(ue && (ue->sequence>0))
        return ue->sequence;
    else
        return 0;
}

void setSequence(UE * ue, int sequence)
{
    assert(sequence > 0);
    if(ue)
        ue->sequence = sequence;
}

void affUE(const UE * ue)
{
    if(ue!=NULL && ue->codeUE > 0 && ue->sequence > 0 && ue->intitule != NULL)
    {
        printf("CodeUE: %d\n"  ,ue->codeUE);
        printf("Intitule: %s\n"  ,ue->intitule);
        printf("Sequence: %d\n"  ,ue->sequence);
    }
    else
    {
        printf("\nAucun UE!!");
    }
}
/* ********************************************************************* */
/*                                                                       */
/*             Fonctions relatives aux gestiond'UE                       */
/*                                                                       */
/* ********************************************************************* */

void savUE(const UE *pUE)
{
    assert(pUE!=NULL  &&  pUE>0 &&  pUE!=NULL   &&  pUE>0);
    savUEParElem(pUE->codeUE,pUE->intitule,pUE->sequence);
}

void savUEParElem(const int CodeUE,const char * Intitule,const int Sequence)
{
    FILE* f;

    f = fopen(UE_DB, "a");

    if (f==NULL)
    {
        printf("Erreur lors de l'ouverture de %s\n", UE_DB);
        exit(EXIT_FAILURE);
    }

    if(rchUEParCode(CodeUE) == 0)
    {
        char*cnum=calloc(20,sizeof(char));
        char*cSequence=calloc(20,sizeof(char));
        sprintf(cnum,"%d",CodeUE);
        sprintf(cSequence,"%d",Sequence);
        char*chaine=calloc(100,sizeof(char));

        strcat(chaine,cnum);
        strcat(chaine,":");
        strcat(chaine,Intitule);
        strcat(chaine,":");
        strcat(chaine,cSequence);
        strcat(chaine,"\n");

        fputs(chaine, f);
    }
    else
        printf("UE  deja presente dans la base de donnée!!!!!\n");

    fclose(f);
}

int rchUE(const UE *pUE)
{
    return  rchUEParCode(pUE->codeUE);
}

int rchUEParCode(const int codeUE)
{
    FILE* f;
    f = fopen(UE_DB, "r");

    if (f==NULL)
    {
        printf("Erreur lors de l'ouverture de %s\n", UE_DB);
        exit(EXIT_FAILURE);
    }

    char* contenu=calloc(100,sizeof(char));
    while(fgets(contenu,100,f)!=NULL)
    {
        char**tabor=g_strsplit((gchar*)contenu,(gchar*)"\n",100);
        char**tab=g_strsplit((gchar*)tabor[0],(gchar*)":",100);
        if(codeUE == atoi(tab[0]))
        {
            fclose(f);
            return 1;
        }
    }

    if(!feof(f))
        printf("autre probleme \n");

    fclose(f);
    return 0;
}



UE *recUEParCode(const int codeUE)
{
    FILE* f;
    f = fopen(UE_DB, "r");

    if (f==NULL)
    {
        printf("Erreur lors de l'ouverture de %s\n", UE_DB);
        exit(EXIT_FAILURE);
    }

    char* contenu=calloc(100,sizeof(char));
    while(fgets(contenu,100,f)!=NULL)
    {
        char**tabor=g_strsplit((gchar*)contenu,(gchar*)"\n",100);
        char**tab=g_strsplit((gchar*)tabor[0],(gchar*)":",100);
        if(codeUE == atoi(tab[0]))
        {
            fclose(f);
            return creUE(codeUE,tab[1],atoi(tab[2]));
        }
    }
    if(!feof(f))
        printf("autre probleme \n");

    fclose(f);
    return NULL;
}

int supUE(const UE *pUE)
{
    assert(pUE!=NULL);
    assert(pUE->codeUE>0);

    return    supUEParCode(pUE->codeUE);
}

int supUEParCode(const int codeUE)
{
    char *contenu=calloc(100,sizeof(char));
    FILE * fIn;
    FILE * fOut;

    if ((fIn = fopen(UE_DB, "r")) == NULL)
        return EXIT_FAILURE;

    if ((fOut = fopen("texte.tmp", "w")) == NULL)
    {
        fclose(fIn);
        return EXIT_FAILURE;
    }

    while (fgets(contenu,100, fIn))
    {
        char * ligne=calloc(100,sizeof(char));
        copStr(&ligne,contenu);
        char**tabor=g_strsplit((gchar*)contenu,(gchar*)"\n",100);
        char**tab=g_strsplit((gchar*)tabor[0],(gchar*)":",100);
        if (atoi(tab[0]) != codeUE)
                    fputs(ligne, fOut);
    }

    fclose(fIn);
    fclose(fOut);

    rename("texte.tmp", UE_DB);
      return 0;   }


int mdfUE(const UE *pUE, const UE *nUE )
{
    if(supUE(pUE)==0)
    {
        savUE(nUE);
         return 0;
    }
   return   -1;

}


int mdfUEParCode(const int codeUE, const UE *nUE)
    {
          if(supUEParCode(codeUE)==0)
        {
            savUE(nUE);
             return 0;
        }
       return   -1;

        }

void affUE_DB()
    {
    FILE* f;

   f = fopen(UE_DB, "r");

    if (f==NULL)
        {
        printf("Erreur lors de l'ouverture de %s\n", UE_DB);
        exit(EXIT_FAILURE);
        }
    char*contenu=calloc(100,sizeof(char));
    while(fgets(contenu,100,f) != NULL)
        {
        char**tabor=g_strsplit((gchar*)contenu,(gchar*)"\n",100);
        char**tab=g_strsplit((gchar*)tabor[0],(gchar*)":",100);
        affUE(creUE(atoi(tab[0]),tab[1],atoi(tab[2])));
        free(tabor);
        free(tab);
        }
    free(contenu);
    if(!feof(f))
        printf("autre probleme \n");
    fclose(f);
    }

/* ********************************************************************* */

/** @brief setResponsableToUe
  *
  * @todo: document this function
  */
void setResponsableToUe(Ens*ens,UE*ue)
{
    setResponsableToUeParCode(ens->numEns,ue->codeUE);
}

void    setResponsableToUeParCode(int   numEns,int  codeUe)
{
    FILE* f;

    f = fopen(RESPUE_DB, "a");

    if (f==NULL)
        {
        printf("Erreur lors de l'ouverture de %s\n", RESPUE_DB);
        exit(EXIT_FAILURE);
        }
    fclose(f);
    if(recResponsableUeParCode(codeUe) ==NULL)
        {
        f = fopen(RESPUE_DB, "a");

        char*c_numEns=calloc(20,sizeof(char));
        char*c_codeUe=calloc(20,sizeof(char));

        sprintf(c_numEns,"%d",numEns);
        sprintf(c_codeUe,"%d",codeUe);

        char*chaine=calloc(100,sizeof(char));

        strcat(chaine,c_codeUe);
        strcat(chaine,":");
        strcat(chaine,c_numEns);
        strcat(chaine,"\n");

        fputs(chaine, f);

        free(chaine);
        free(c_codeUe);
        free(c_numEns);

        fclose(f);
        }
        else
        {
            supRespUEParCode(codeUe);
            setResponsableToUeParCode(numEns,codeUe);
        }
}

Ens * recResponsableUe(UE*ue)
{
    return  recResponsableUeParCode(ue->codeUE);
}

Ens * recResponsableUeParCode(int codeUe)
{
    char *contenu=calloc(100,sizeof(char));
    FILE * f;

    if ((f = fopen(RESPUE_DB, "r")) == NULL)
    {
        return NULL;
    }

    while (fgets(contenu,100, f))
    {
        char * ligne=calloc(100,sizeof(char));
        strcpy(ligne,contenu);
        char**tabor=g_strsplit((gchar*)contenu,(gchar*)"\n",100);
        char**tab=g_strsplit((gchar*)tabor[0],(gchar*)":",100);
        if (atoi(tab[0]) == codeUe)
        {
            fclose(f);
            int    numEns=atoi(tab[1]);
            free(tabor);
            free(tab);
            free(contenu);
            free(ligne);
            return  recEnsParCode(numEns);
        }
        free(tabor);
        free(tab);
        free(ligne);
    }
    free(contenu);

    fclose(f);
    return  NULL;
}

int supRespUE(UE*ue)
{
    return  supRespUEParCode(ue->codeUE);
}

int supRespUEParCode(int    codeUe)
{
    char *contenu=calloc(100,sizeof(char));
    FILE * fIn;
    FILE * fOut;

    if ((fIn = fopen(RESPUE_DB, "r")) == NULL)
        return EXIT_FAILURE;

    if ((fOut = fopen("texte.tmp", "w")) == NULL)
    {
        fclose(fIn);
        return EXIT_FAILURE;
    }

    while (fgets(contenu,100, fIn))
    {
        char * ligne=calloc(100,sizeof(char));
        strcpy(ligne,contenu);
        char**tabor=g_strsplit((gchar*)contenu,(gchar*)"\n",100);
        char**tab=g_strsplit((gchar*)tabor[0],(gchar*)":",100);
        if (atoi(tab[0]) !=codeUe)
            fputs(ligne, fOut);

        free(ligne);
        free(tabor);
    }
    free(contenu);
    fclose(fIn);
    fclose(fOut);

    rename("texte.tmp", RESPUE_DB);
    return  0;
}



/** @brief recUeParNumEnseignantResp
  *
  * @todo: document this function
  */
TabUe* recUeParNumEnseignantResp(int numEns)
{
    FILE* f;
    int i=1;
    UE **ues=calloc(i,sizeof(UE));

    f = fopen(RESPUE_DB, "r");

    if (f==NULL)
    {
        printf("Erreur lors de l'ouverture de %s\n", RESPUE_DB);
        exit(EXIT_FAILURE);
    }
    char*contenu=calloc(100,sizeof(char));

    while(fgets(contenu,100,f) != NULL)
    {
        char**tabor=g_strsplit((gchar*)contenu,(gchar*)"\n",100);
        char**tab=g_strsplit((gchar*)tabor[0],(gchar*)":",100);
        if(numEns==atoi(tab[1]))
        {
            ues=realloc(ues,sizeof(UE)*i);
            ues[i-1]=recUEParCode(atoi(tab[0]));
            i++;
        }
        free(tabor);
        free(tab);
    }
    free(contenu);
    if(!feof(f))
        printf("autre probleme \n");

    fclose(f);
    TabUe*tabUe=calloc(1,sizeof(TabUe));
    tabUe->tabUe=ues;
    tabUe->nbUe=i-1;
    return tabUe;
}

/** @brief recUeParEnseignantResp
  *
  * @todo: document this function
  */
TabUe* recUeParEnseignantResp(Ens*ens)
{
    assert(ens!=NULL);
    return  recUeParNumEnseignantResp(ens->numEns);
}


/** @brief recToutUe
  *
  * @todo: document this function
  */
TabUe* recToutUe()
{
    FILE* f;
    int i=1;
    UE **ues=calloc(i,sizeof(UE));

    f = fopen(UE_DB, "r");

    if (f==NULL)
    {
        printf("Erreur lors de l'ouverture de %s\n", UE_DB);
        exit(EXIT_FAILURE);
    }
    char*contenu=(char*)calloc(100,sizeof(char));

    while(fgets(contenu,100,f) != NULL)
    {
        char**tabor=g_strsplit((gchar*)contenu,(gchar*)"\n",100);
        char**tab=g_strsplit((gchar*)tabor[0],(gchar*)":",100);
        ues=realloc(ues,sizeof(UE)*i);
        char*intitule=(char*)calloc(20,sizeof(char));
        strcpy(intitule,tab[1]);
        ues[i-1]=creUE(atoi(tab[0]),intitule,atoi(tab[2]));
        i++;
        free(tabor);
    }
    free(contenu);
    if(!feof(f))
        printf("autre probleme \n");

    fclose(f);
    TabUe*tabUe=calloc(1,sizeof(TabUe));
    tabUe->tabUe=ues;
    tabUe->nbUe=i-1;
    return tabUe;
}


void regUE()
    {
    UE ue1, ue2;
    UE *ue3, *ue4, *ue5, *ue6, *ue7;

    printf("\n\nTest de regression du module UE :\n") ;

    printf("\nTest de initUE pour un UE de code 1, de Intitule LIF1, de Sequence 1  : ");
    initUE(&ue1, 1, "LIF7", 1 ) ;
    affUE(&ue1);
    printf("OK.\n") ;

    printf("\nTest de initUE pour un UE de code 2, de Intitule LIF2, de Sequence 2  : ");
    initUE(&ue2, 2, "LIF2", 2 ) ;
    affUE(&ue2);
    printf("OK.\n") ;

    printf("\nTest de libereUE pour un l'eu de code 1, de Intitule LIF1, de Sequence 1  : ");
    libUE(&ue1) ;
    printf("OK.\n") ;
    printf("Affichage après liberation\n");
    affUE(&ue1);
    printf("OK.\n") ;

    printf("\nTest de libereUE pour un l'eu de code 2, de Intitule LIF2, de Sequence 2  : ");
    libUE(&ue2) ;
    printf("OK.\n") ;
    printf("Affichage après liberation\n");
    affUE(&ue2);
    printf("OK.\n") ;

    printf("\nTest de creerUE pour un UE de code 3, de Intitule LIF3, de Sequence 3  :  ");
    ue3=creUE(3,"LIF3",3);
    affUE(ue3);
    printf("OK.\n") ;

    printf("\nTest de savUE pour trois UE  :  ");
    savUE(ue3);
    detUE(&ue3) ;

    ue4=creUE(4,"LIF4",4);
    /*savUEParElem(4,"LIF4",4,DB);*/
    savUE(ue4);
    detUE(&ue4) ;

    ue5=creUE(5,"LIF5",5);
    /*savUEParElem(5,"LIF5",5,DB);*/
    savUE(ue5);
    detUE(&ue5) ;
    printf("OK.\n") ;

    printf("\nTest de affUE_DB pour trois UE  :  ");
    affUE_DB();
    printf("OK.\n") ;

    printf("\nTest de supUE pour un UE de code 3, de Intitule LIF3, de Sequence 3  :  ");
    supUEParCode(3);
    affUE_DB();
    printf("OK.\n") ;

    printf("\nTest de mdfUE pour un UE de code 5 à 6   :  ");
    ue6=creUE(6,"LIF6",6);
    /*setIntitule_UE(ue6, "ddddddddddd");*/
    mdfUEParCode(5, ue6);
    mdfUEParCode(3, ue6);
    detUE(&ue6);

    affUE_DB();
    printf("OK.\n") ;

    printf("\nTest de recUEParCode pour un UE de code 4   :  ");
    ue7=recUEParCode(4);
    affUE(ue7);
    detUE(&ue7);
    printf("\nTest de detruireUE pour un l'eu de code 3, de Intitule LIF3, de Sequence 3  : ");




    printf("OK.\n") ;
    printf("Affichage apres destruction\n");
    affUE(ue3);

    /*remove(UE_DB);*/
    printf("\nTest de regression du module UE terminé avec succés.\n\n") ;

    }


